home *** CD-ROM | disk | FTP | other *** search
/ CD Actual Thematic 25: Programming / pc_actual_25.iso / Delphi / Duck Report / _SETUP.1 / QueryEditor.pas < prev    next >
Encoding:
Pascal/Delphi Source File  |  1999-01-18  |  38.1 KB  |  1,358 lines
  1. unit QueryEditor;
  2. {$I DQuery.inc}
  3.  
  4. interface
  5.  
  6. uses
  7.     {$IFDEF WIN32}
  8.         Windows, ComCtrls,
  9.     {$ELSE}
  10.         WinTypes, WinProcs,
  11.     {$ENDIF}
  12.   Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
  13.     StdCtrls, Buttons, Tabnotbk, DB, DBTables,
  14.   ExtCtrls, dclDQuery, DQLinkCtrl;
  15. Const
  16.     IDW_TablesNotFound    = 'Prease insert table before continue';
  17.   IDW_ALIAS_REDEFINE    = 'The Alias [%s] redefine.';
  18.   IDW_SORT_REDEFINE        = 'The Sort [%s] redefine.';
  19.   IDW_GROUP_REDEFINE    = 'The Group [%s] redefine.';
  20. type
  21.   TFormQuery = class(TForm)
  22.     TNotebook: TTabbedNotebook;
  23.     BBViewData: TBitBtn;
  24.     BBViewSQL: TBitBtn;
  25.     BBOK: TBitBtn;
  26.     BBCancel: TBitBtn;
  27.     BBHelp: TBitBtn;
  28.     GroupBox1: TGroupBox;
  29.     BBBDE: TBitBtn;
  30.     BBTable: TBitBtn;
  31.     LinkCtrl: TDQLinkCtrl;
  32.     BBDeleteLink: TBitBtn;
  33.     BBOptionLine: TBitBtn;
  34.     BBArrange: TBitBtn;
  35.     BBSortAdd: TBitBtn;
  36.     BBSortRemove: TBitBtn;
  37.     Label5: TLabel;
  38.     FieldAllField: TTreeView;
  39.     BBFieldsAdd: TBitBtn;
  40.     BBFieldsRemove: TBitBtn;
  41.     BBAddShowTable: TBitBtn;
  42.     BBRemoveShowAll: TBitBtn;
  43.     GroupBox2: TGroupBox;
  44.     Label7: TLabel;
  45.     Label8: TLabel;
  46.     Label9: TLabel;
  47.     CBFunction: TComboBox;
  48.     ESelectField: TEdit;
  49.     EColumnName: TEdit;
  50.     GroupBox3: TGroupBox;
  51.     LBSelect: TListBox;
  52.     GroupBox4: TGroupBox;
  53.     LabelAnd: TLabel;
  54.     CBField: TComboBox;
  55.     CBCommand: TComboBox;
  56.     BBAdd: TBitBtn;
  57.     BBRemove: TBitBtn;
  58.     BBEdit: TBitBtn;
  59.     BBClear: TBitBtn;
  60.     GroupBox5: TGroupBox;
  61.     LBTable: TListBox;
  62.     GroupBox6: TGroupBox;
  63.     GroupBox7: TGroupBox;
  64.     LBSort: TListBox;
  65.     RGSort: TRadioGroup;
  66.     GroupBox8: TGroupBox;
  67.     ListBoxSelect: TListBox;
  68.     GroupBox9: TGroupBox;
  69.     BBGroupAdd: TBitBtn;
  70.     BBGroupRemove: TBitBtn;
  71.     GroupBox10: TGroupBox;
  72.     LBGroup: TListBox;
  73.     BBAddFields: TBitBtn;
  74.     LBSortAll: TListBox;
  75.     LBGroupsAll: TListBox;
  76.     GroupBox11: TGroupBox;
  77.     BBRemoveTable: TBitBtn;
  78.     GroupBox12: TGroupBox;
  79.     CBRemove: TCheckBox;
  80.     CBValue1: TEdit;
  81.     CBValue2: TEdit;
  82.     SBValue1: TSpeedButton;
  83.     SBValue2: TSpeedButton;
  84.     OpenDBDlg: TOpenDialog;
  85.     RBCriteriaWith: TRadioGroup;
  86.     procedure FormCreate(Sender: TObject);
  87.     procedure FormDestroy(Sender: TObject);
  88.     procedure FormShow(Sender: TObject);
  89.     procedure BBOKClick(Sender: TObject);
  90.     procedure BBCancelClick(Sender: TObject);
  91.     procedure BBHelpClick(Sender: TObject);
  92.     procedure BBViewDataClick(Sender: TObject);
  93.     procedure BBViewSQLClick(Sender: TObject);
  94.     procedure FormClose(Sender: TObject; var Action: TCloseAction);
  95.     procedure TNotebookChange(Sender: TObject; NewTab: Integer;
  96.       var AllowChange: Boolean);
  97.     procedure BBBDEClick(Sender: TObject);
  98.     procedure BBTableClick(Sender: TObject);
  99.     procedure BBRemoveTableClick(Sender: TObject);
  100.     procedure BBDeleteLinkClick(Sender: TObject);
  101.     procedure BBOptionLineClick(Sender: TObject);
  102.     procedure BBArrangeClick(Sender: TObject);
  103.     procedure LinkCtrlNewLink(Sender: TObject);
  104.     procedure LinkCtrlSelectLinkEvent(Sender: TObject; bSelect: Boolean);
  105.     procedure BBFieldsAddClick(Sender: TObject);
  106.     procedure BBFieldsRemoveClick(Sender: TObject);
  107.     procedure BBAddShowTableClick(Sender: TObject);
  108.     procedure BBAddFieldsClick(Sender: TObject);
  109.     procedure BBRemoveShowAllClick(Sender: TObject);
  110.     procedure FieldAllFieldClick(Sender: TObject);
  111.     procedure CBFunctionClick(Sender: TObject);
  112.     procedure BBSortAddClick(Sender: TObject);
  113.     procedure BBSortRemoveClick(Sender: TObject);
  114.     procedure RGSortClick(Sender: TObject);
  115.     procedure ListBoxSelectDragDrop(Sender, Source: TObject; X,
  116.       Y: Integer);
  117.     procedure ListBoxSelectDragOver(Sender, Source: TObject; X, Y: Integer;
  118.       State: TDragState; var Accept: Boolean);
  119.     procedure LBSortDragDrop(Sender, Source: TObject; X, Y: Integer);
  120.     procedure LBSortDragOver(Sender, Source: TObject; X, Y: Integer;
  121.       State: TDragState; var Accept: Boolean);
  122.     procedure LBSortClick(Sender: TObject);
  123.     procedure BBGroupAddClick(Sender: TObject);
  124.     procedure BBGroupRemoveClick(Sender: TObject);
  125.     procedure LBGroupDragDrop(Sender, Source: TObject; X, Y: Integer);
  126.     procedure LBGroupDragOver(Sender, Source: TObject; X, Y: Integer;
  127.       State: TDragState; var Accept: Boolean);
  128.     procedure CBFieldClick(Sender: TObject);
  129.     procedure CBCommandClick(Sender: TObject);
  130.     procedure BBAddClick(Sender: TObject);
  131.     procedure BBRemoveClick(Sender: TObject);
  132.     procedure BBEditClick(Sender: TObject);
  133.     procedure BBClearClick(Sender: TObject);
  134.     procedure LBSelectDragDrop(Sender, Source: TObject; X, Y: Integer);
  135.     procedure LBSelectDragOver(Sender, Source: TObject; X, Y: Integer;
  136.       State: TDragState; var Accept: Boolean);
  137.     procedure LBSelectClick(Sender: TObject);
  138.     procedure SBValue1Click(Sender: TObject);
  139.     procedure SBValue2Click(Sender: TObject);
  140.   private
  141.         StDataBase:        String;
  142.         StTable:            String;
  143.         StAlias:            String;
  144.      bMultiDB:        Boolean;
  145.  
  146.      Function        SetupValue: Boolean;
  147.      Procedure    AddTable (Sender: TObject);
  148.      Procedure    NewTable;
  149.      Procedure    AddFieldInfoToAllControl (StAlias: String);
  150.      Procedure    RemoveFieldInfoToAllControl (StAlias: String);
  151.  
  152.      { Link }
  153.      Procedure    GetTableLink;
  154.  
  155.      { Select Fields }
  156.      Procedure    SelectField;
  157.      Procedure    EnabledField;
  158.      Procedure    AddFieldWithAlias (StAlias: String);
  159.  
  160.      { Criteria }
  161.         Procedure    VisibleCriteria (bV1, bV2: Boolean);
  162.      Procedure    GetCriterias (Var DQCriterias: RDQCriterias);
  163.      Procedure    SetCriterias (DQCriterias: RDQCriterias);
  164.  
  165.      { Table Info }
  166.      Procedure    DestroyTableInfo;
  167.      Procedure    CreateTableInfos;
  168.      Procedure    CreateTableInfo (StDB, StTable, StAlias: String; bWait: Boolean);
  169.      Function        CriteriasAsString (iCount: Integer; CriteriasPtr: PRDQCriterias): String;
  170.      Function        GetLastNode (TreeView: TTreeView): TTreeNode;
  171.      Procedure    GetSelectField (Items: TStrings);
  172.      Function        FieldSelect (TreeView: TTreeView; Var StAlias: String): String;
  173.      Procedure    CheckColumnNameDup (Var St: String);
  174.      Procedure    DeleteTreeViewByAlias (TreeView: TTreeView; StAlias: String);
  175.      Function        FindAlias (TreeView: TTreeView; StAlias: String): TTreeNode;
  176.      Procedure    LoadQueryToScreen;
  177.      Procedure    RemoveObjectWithAlias (StAlias: String);
  178.      Procedure    GetTableAndField (StColumn: String; Var StDB, StTable, StAlias, StField: String);
  179.      Procedure    LoadFieldToScreen;
  180.   public
  181.      DuckQuery:    TDuckQuery;
  182.   end;
  183.  
  184. var
  185.   FormQuery: TFormQuery;
  186.  
  187. implementation
  188.  
  189. Uses DQAddTable, DQViewText, DQViewData, DQSelectV;
  190. {$R *.DFM}
  191.  
  192. Function    MessageBoxWarning (St: String): Integer;
  193. Begin
  194.     Result    := MessageDlg (St, mtWarning, [mbOK], 0);
  195. End;
  196. Function    MessageBoxFormatWarning (St: String; const Args: array of const): Integer;
  197. Begin
  198.     Result    := MessageDlg (Format (St, Args), mtWarning, [mbOK], 0);
  199. End;
  200. Function CheckColumnName (StColumnName: String): String;
  201. Begin
  202.     Result    := DQCutCharInString (StColumnName,' ().');
  203. End;
  204. Function GetAlias (TreeView: TTreeView): String;
  205. Begin
  206.     Result    := '';
  207.   if TreeView.Selected = nil Then Exit;
  208.   if TreeView.Selected.Parent = nil Then
  209.       Result    := TreeView.Selected.Text
  210.   Else
  211.       Result    := TreeView.Selected.Parent.Text;
  212. End;
  213. Procedure TFormQuery.FormCreate(Sender: TObject);
  214. Begin
  215.     DuckQuery    := TDuckQuery.Create (Self);
  216.   bMultiDB        := TRUE;
  217.   TNotebook.PageIndex    := 0;
  218.   SendMessage (LBSelect.Handle, LB_SETHORIZONTALEXTENT, 1000, 0);
  219. End;
  220. Procedure TFormQuery.FormDestroy(Sender: TObject);
  221. Begin
  222.     DestroyTableInfo;
  223.     DuckQuery.Free;
  224.     FormQuery    := nil;
  225. End;
  226. Procedure TFormQuery.FormClose(Sender: TObject; var Action: TCloseAction);
  227. Begin
  228.     Action    := caFree;
  229. End;
  230. Procedure TFormQuery.DestroyTableInfo;
  231. Var
  232.     TableInfoPtr:    PRDQTableInfo;
  233.   i:                    Integer;
  234. Begin
  235.     For i := 0 To DuckQuery.TableInfo.Count - 1 Do
  236.   Begin
  237.       TableInfoPtr    := DuckQuery.TableInfo[i];
  238.      if TableInfoPtr^.Table <> nil  Then
  239.          TableInfoPtr^.Table.Free;
  240.      if TableInfoPtr^.FieldName <> nil Then
  241.          TableInfoPtr^.FieldName.Free;
  242.     End;
  243.   DuckQuery.TableInfo.Clear;
  244. End;
  245. Procedure TFormQuery.CreateTableInfos;
  246. Var
  247.     TableInfo:        RDQTableInfo;
  248.   TablePtr:        PRDQTable;
  249.   i:                    Integer;
  250.     Cursor:            TCursor;
  251. Begin
  252.     if DuckQuery.DQTables.Count <= 0 Then Exit;
  253.     Cursor            := Screen.Cursor;
  254.     Screen.Cursor    := crHourGlass;
  255.  
  256.   Try
  257.         For i := 0 To DuckQuery.DQTables.Count - 1 Do
  258.         Begin
  259.           TablePtr    := DuckQuery.DQTables[i];
  260.         CreateTableInfo (TablePtr.DataBase, TablePtr.Table,
  261.             TablePtr.Alias, FALSE);
  262.         End;
  263.   Finally
  264.       Screen.Cursor := Cursor;
  265.   End;
  266. End;
  267. Procedure TFormQuery.CreateTableInfo (StDB, StTable, StAlias: String; bWait: Boolean);
  268. Var
  269.     TableInfo:        RDQTableInfo;
  270.   i:                    Integer;
  271.     Cursor:            TCursor;
  272. Begin
  273.     if bWait Then
  274.   Begin
  275.         Cursor            := Screen.Cursor;
  276.       Screen.Cursor    := crHourGlass;
  277.   End;
  278.   TableInfo.Alias    := StAlias;
  279.   TableInfo.Table    := TTable.Create (nil);
  280.   Try
  281.         if StDB <> '' Then
  282.             TableInfo.Table.Databasename    := StDB;
  283.         TableInfo.Table.TableName        := StTable;
  284.      Try
  285.          TableInfo.Table.Active            := TRUE;
  286.      Finally
  287.          if TableInfo.Table.Active Then
  288.         Begin
  289.             TableInfo.FieldName    := TStringList.Create;
  290.            For i := 0 to TableInfo.Table.FieldCount - 1 Do
  291.                     TableInfo.FieldName.Add (TableInfo.Table.Fields[i].FieldName);
  292.            With TableInfo.FieldName as TStringList Do
  293.            Begin
  294.                Sorted    := TRUE;
  295.                     Sorted    := FALSE;
  296.            End;
  297.            DuckQuery.TableInfo.Add (@TableInfo);
  298.         End;
  299.      End;
  300.   Finally
  301.       if bWait Then
  302.       Begin
  303.           Screen.Cursor := Cursor;
  304.      End;
  305.   End;
  306. End;
  307. Procedure TFormQuery.LoadQueryToScreen;
  308. Var
  309.   i:                    Integer;
  310.   GroupPtr:        PRDQGroup;
  311.   SortPtr:            PRDQSort;
  312.   CriteriasPtr:    PRDQCriterias;
  313.   St:                String;
  314. Begin
  315.     GetSelectField (ListBoxSelect.Items);
  316.   LoadFieldToScreen;
  317.   
  318.   LBGroup.Items.BeginUpdate;
  319.   For i := 0 To DuckQuery.DQGroups.Count - 1 Do
  320.   Begin
  321.         GroupPtr    := DuckQuery.DQGroups[i];
  322.      LBGroup.Items.Add (GroupPtr.Field);
  323.   End;
  324.   LBGroup.Items.EndUpdate;
  325.  
  326.   LBSort.Items.BeginUpdate;
  327.   For i := 0 To DuckQuery.DQSorts.Count - 1 Do
  328.   Begin
  329.         SortPtr    := DuckQuery.DQSorts[i];
  330.      if SortPtr.SortType = gsAscending Then
  331.          LBSort.Items.Add ('A - ' + SortPtr.Field)
  332.      Else
  333.          LBSort.Items.Add ('D - ' + SortPtr.Field);
  334.   End;
  335.   LBSort.Items.EndUpdate;
  336.  
  337.   LBSelect.Items.BeginUpdate;
  338.   For i := 0 To DuckQuery.DQCriterias.Count - 1 Do
  339.   Begin
  340.         CriteriasPtr    := DuckQuery.DQCriterias[i];
  341.      St                    := CriteriasAsString (i, CriteriasPtr);
  342.         LBSelect.Items.Add (St);
  343.   End;
  344.   LBSelect.Items.EndUpdate;
  345.   RBCriteriaWith.Visible    := DuckQuery.DQCriterias.Count > 0;
  346. End;
  347. Procedure TFormQuery.RemoveObjectWithAlias (StAlias: String);
  348. Var
  349.     i:                    Integer;
  350.   TablePtr:        PRDQTable;
  351.   GroupPtr:        PRDQGroup;
  352.   SortPtr:            PRDQSort;
  353.   CriteriasPtr:    PRDQCriterias;
  354.   FieldPtr:        PRDQField;
  355.   StFind:            String;
  356.   iFind:            Integer;
  357. Begin
  358.     // Remove Table
  359.     i    := 0;
  360.     While i < DuckQuery.DQTables.Count Do
  361.   Begin
  362.       TablePtr    := DuckQuery.DQTables[i];
  363.      if TablePtr.Alias = StAlias Then
  364.      Begin
  365.             DuckQuery.DQTables.Delete (i);
  366.         Continue;
  367.      End;
  368.       Inc (i);
  369.   End;
  370.  
  371.   // Remove Field
  372.   i            := 0;
  373.   StFind    := StAlias + '.';
  374.     While i < DuckQuery.DQFields.Count Do
  375.   Begin
  376.      FieldPtr    := DuckQuery.DQFields[i];
  377.      if Pos (StFind, FieldPtr.Data) > 0 Then
  378.      Begin
  379.         iFind    := DuckQuery.DQGroups.FindAsString (FieldPtr.ColumnName);
  380.         if iFind >= 0 Then
  381.             DuckQuery.DQGroups.Delete (iFind);
  382.         iFind    := DuckQuery.DQSorts.FindAsString (FieldPtr.ColumnName);
  383.         if iFind >= 0 Then
  384.             DuckQuery.DQSorts.Delete (iFind);
  385.         iFind    := DuckQuery.DQCriterias.FindAsString (FieldPtr.ColumnName);
  386.         if iFind >= 0 Then
  387.             DuckQuery.DQCriterias.Delete (iFind);
  388.  
  389.         DuckQuery.DQFields.Delete (i);
  390.         Continue;
  391.      End;
  392.       Inc (i);
  393.   End;
  394. End;
  395. Procedure TFormQuery.FormShow(Sender: TObject);
  396. Var
  397.   i:                    Integer;
  398.   QueryLink:        RQueryLink;
  399.   TablePtr:        PRDQTable;
  400.     LinkPtr:            PRDQLink;
  401.   AllowChange:    Boolean;
  402.   {$IFDEF VERIFY_MSACCESS}  
  403.   TempSession:    TSession;
  404.   St:                String;
  405.   {$ENDIF}
  406. Begin
  407.     CreateTableInfos;
  408.   LBTable.Items.BeginUpdate;
  409.   Try
  410.       For i := 0 To DuckQuery.DQTables.Count - 1 Do
  411.         Begin
  412.          TablePtr    := DuckQuery.DQTables[i];
  413.         AddFieldInfoToAllControl (TablePtr.Alias);
  414.          LBTable.Items.Add (TablePtr.Alias);
  415.          {$IFDEF VERIFY_MSACCESS}
  416.         if i = 0 Then
  417.         Begin
  418.              TempSession    := DuckQuery.DBSession;
  419.               if TempSession = nil Then
  420.                   TempSession    := Session;
  421.            if (TablePtr.DataBase <> '') and
  422.                (TablePtr.DataBase[Length (TablePtr.DataBase)] <> '\') Then
  423.                 Begin
  424.                St    := TempSession.GetAliasDriverName (TablePtr.DataBase);
  425.                     if St = 'MSACCESS' Then
  426.                    bMultiDB    := FALSE;
  427.            End;
  428.         End;
  429.             {$ENDIF}
  430.         End;
  431.   Finally
  432.       LBTable.Items.EndUpdate;
  433.   End;
  434.   For i := 0 To DuckQuery.DQTableLinks.Count - 1 Do
  435.   Begin
  436.       LinkPtr                := DuckQuery.DQTableLinks[i];
  437.      QueryLink.MAlias    := LinkPtr.MAlias;
  438.         QueryLink.MField    := LinkPtr.MField;
  439.         QueryLink.DAlias    := LinkPtr.DAlias;
  440.         QueryLink.DField    := LinkPtr.DField;
  441.         QueryLink.QueryLinkType    := TQueryLinkType (LinkPtr.TableLinkType);
  442.         LinkCtrl.AddLink (QueryLink);
  443.   End;
  444.     LinkCtrl.ReInitTableLink;
  445.  
  446.   LoadQueryToScreen;
  447.  
  448. //  LBGroup
  449.     BBGroupRemove.Enabled    := LBGroup.Items.Count > 0;
  450.   BBSortRemove.Enabled        := LBSort.Items.Count > 0;
  451.   BBRemove.Enabled            := LBSelect.Items.Count > 0;
  452.   EnabledField;
  453.   AllowChange    := TRUE;
  454.     TNotebookChange (nil, TNotebook.PageIndex, AllowChange);
  455.   CBRemove.Checked    := DuckQuery.Duplicate;
  456. End;
  457. Function TFormQuery.CriteriasAsString (iCount: Integer; CriteriasPtr: PRDQCriterias): String;
  458. Begin
  459.     Result    := CriteriasPtr.Field;
  460.   Case CriteriasPtr.CriteriaType of
  461.         scEqual:                Result    := Result + ' = ';
  462.      scNotEqual:            Result    := Result + ' <> ';
  463.      scLess:                Result    := Result + ' < ';
  464.      scLessEqual:        Result    := Result + ' <= ';
  465.      scGreater:            Result    := Result + ' > ';
  466.         scGreaterEqual:    Result    := Result + ' >= ';
  467.      scBetween:            Result    := Result + ' > ';
  468.      scBetweenEqual:    Result    := Result + ' >= ';
  469.      scNOTNULL:            Result    := Result + ' IS NOT NULL';
  470.      scNULL:                Result    := Result + ' IS NOT';
  471.      scIN:                    Result    := Result + ' IN ( ';
  472.      scLike:                Result    := Result + ' LIKE ';
  473.      scNotLike:            Result    := Result + ' NOT LIKE ';
  474.     End;
  475.     Result    := Result + CriteriasPtr.Value1;
  476.   if (CriteriasPtr.CriteriaType = scBetween) or
  477.       (CriteriasPtr.CriteriaType = scBetweenEqual) Then
  478.   Begin
  479.       Case CriteriasPtr.CriteriaType of
  480.          scBetween:            Result    := Result + ' AND < ';
  481.          scBetweenEqual:    Result    := Result + ' AND >= ';
  482.       End;
  483.         Result    := Result + CriteriasPtr.Value2;
  484.   End;
  485.   Case CriteriasPtr.CriteriaType of
  486.      scIN:                    Result    := Result + ' )';
  487.     End;
  488.   if iCount > 0 Then
  489.     Begin
  490.         if CriteriasPtr.AddType = caAnd Then
  491.             Result    := 'AND ' + Result
  492.      Else
  493.             Result    := 'OR ' + Result;
  494.     End;
  495. End;
  496. Function TFormQuery.GetLastNode (TreeView: TTreeView): TTreeNode;
  497. Var
  498.     TreeNode:    TTreeNode;
  499. Begin
  500.     TreeNode    := TreeView.Items.GetFirstNode;
  501.   Result    := nil;
  502.   While TreeNode <> nil Do
  503.   Begin
  504.       Result    := TreeNode;
  505.       TreeNode    := TreeNode.GetNextChild (TreeNode);
  506.   End;
  507. End;
  508. Procedure TFormQuery.GetSelectField (Items: TStrings);
  509. Var
  510.     i:                Integer;
  511.   FieldPtr:    PRDQField;
  512. Begin
  513.     Items.BeginUpdate;
  514.   Items.Clear;
  515.   Try
  516.       For i := 0 To DuckQuery.DQFields.Count - 1 Do
  517.       Begin
  518.             FieldPtr    := DuckQuery.DQFields[i];
  519.          Items.Add (FieldPtr.ColumnName);
  520.       End;
  521.   Finally
  522.       Items.EndUpdate;
  523.   End;
  524. End;
  525. Function TFormQuery.FieldSelect (TreeView: TTreeView; Var StAlias: String): String;
  526. Begin
  527.     Result    := '';
  528.   StAlias    := '';
  529.   if TreeView.Selected = nil Then Exit;
  530.   if TreeView.Selected.Parent = nil Then Exit;
  531.   Result    := TreeView.Selected.Text;
  532.   StAlias    := TreeView.Selected.Parent.Text;
  533. End;
  534. Procedure TFormQuery.CheckColumnNameDup (Var St: String);
  535. Var
  536.     i:            Integer;
  537.   StTemp:    String;
  538. Begin
  539.     StTemp    := St;
  540.   i            := 0;
  541.     While (TRUE) Do
  542.   Begin
  543.         if DuckQuery.DQFields.FindAsString (StTemp) = -1 Then Break; 
  544.      Inc (i);
  545.      StTemp    := St + IntToStr (i);
  546.   End;
  547.   St    := StTemp;
  548. End;
  549. Procedure TFormQuery.DeleteTreeViewByAlias (TreeView: TTreeView; StAlias: String);
  550. Var
  551.     TreeNode:    TTreeNode;
  552. Begin
  553.     TreeNode    := FindAlias (TreeView, StAlias);
  554.   if TreeNode <> nil Then
  555.         TreeNode.Free;
  556. End;
  557. Function TFormQuery.FindAlias (TreeView: TTreeView; StAlias: String): TTreeNode;
  558. Var
  559.     TreeNode:    TTreeNode;
  560. Begin
  561.     TreeNode    := TreeView.Items.GetFirstNode;
  562.   While TreeNode <> nil Do
  563.   Begin
  564.       if TreeNode.Text = StAlias Then
  565.         Break;
  566.       TreeNode    := TreeNode.GetNextChild (TreeNode);
  567.   End;
  568.   Result    := TreeNode;
  569. End;
  570. Function TFormQuery.SetupValue: Boolean;
  571. Var
  572.     i:        Integer;
  573. Begin
  574.     Result    := FALSE;
  575.     if DuckQuery.DQFields.Count <= 0 Then
  576.     Begin
  577.       i    := TNotebook.GetIndexForPage ('Fields');
  578.      TNotebook.PageIndex    := i;
  579.      FieldAllField.SetFocus;
  580.      MessageBoxWarning (IDW_TablesNotFound);
  581.      Exit;
  582.     End;
  583.     DuckQuery.Duplicate    := CBRemove.Checked;
  584.     GetTableLink;
  585.   Result    := TRUE;
  586. End;
  587. Procedure TFormQuery.BBOKClick(Sender: TObject);
  588. Begin
  589.     if not SetupValue Then Exit;
  590.     Close;
  591.   ModalResult    := mrOK;
  592. End;
  593. Procedure TFormQuery.BBCancelClick(Sender: TObject);
  594. Begin
  595.     Close;
  596.   ModalResult    := mrCancel;
  597. End;
  598. Procedure TFormQuery.BBHelpClick(Sender: TObject);
  599. Begin
  600.     Beep;
  601. End;
  602. Procedure TFormQuery.AddTable (Sender: TObject);
  603. Begin
  604.     StDataBase    := FormDQAddTable.StDataBase;
  605.     StTable        := FormDQAddTable.StTable;
  606.     StAlias        := FormDQAddTable.StAlias;
  607.   NewTable;
  608. End;
  609. Procedure TFormQuery.AddFieldInfoToAllControl (StAlias: String);
  610. Var
  611.     Items:            TStrings;
  612.   TableInfoPtr:    PRDQTableInfo;
  613.   St:                String;
  614.   TreeNode:        TTreeNode;
  615.   i:                    Integer;
  616. Begin
  617.     TableInfoPtr    := DuckQuery.TableInfo.FindAsStringPt (StAlias);
  618.   if TableInfoPtr = nil Then Exit;
  619.     Items    := TStringList.Create;
  620.   Try
  621.      Items.Assign (TableInfoPtr.FieldName);
  622.      TreeNode    := GetLastNode (FieldAllField);
  623.         TreeNode    := FieldAllField.Items.Add (TreeNode, StAlias);
  624.         For i := 0 to Items.Count - 1 Do
  625.         Begin
  626.             St            := Items[i];
  627.             FieldAllField.Items.AddChild (TreeNode, St);
  628.         End;
  629.  
  630.         LinkCtrl.AddTable (StDataBase, StTable, StAlias, Items);
  631.   Finally
  632.       Items.Free;
  633.   End;
  634. End;
  635. Procedure TFormQuery.RemoveFieldInfoToAllControl (StAlias: String);
  636. Begin
  637.     LinkCtrl.DeleteControl (StAlias);
  638.   DeleteTreeViewByAlias (FieldAllField, StAlias);
  639.   RemoveObjectWithAlias (StAlias);
  640.   LoadQueryToScreen;
  641.   BBGroupRemove.Enabled    := LBGroup.Items.Count > 0;
  642.   BBSortRemove.Enabled        := LBSort.Items.Count > 0;
  643.     BBRemove.Enabled            := LBSelect.Items.Count > 0;
  644. End;
  645. Procedure TFormQuery.BBViewDataClick(Sender: TObject);
  646. Var
  647.     DQ:    TDuckQuery;
  648. Begin
  649.     if not SetupValue Then Exit;
  650.     Screen.Cursor    := crHourGlass;
  651.     DQ    := TDuckQuery.Create (Self);
  652.     Try
  653.         DQ.Assign (DuckQuery);
  654.         DQ.DoSQL;
  655.         DQ.Active    := TRUE;
  656.         FormDQViewData    := TFormDQViewData.Create (Self);
  657.       FormDQViewData.DataSource.DataSet    := DQ;
  658.       FormDQViewData.ShowModal;
  659.      FormDQViewData.Free;
  660.     Finally
  661.       DQ.Free;
  662.         Screen.Cursor    := crDefault;
  663.     End;
  664.  
  665. End;
  666. Procedure TFormQuery.BBViewSQLClick(Sender: TObject);
  667. Begin
  668.     if not SetupValue Then Exit;
  669.     FormDQViewText    := TFormDQViewText.Create (Self);
  670.   DuckQuery.GetSQL (FormDQViewText.Memo.Lines);
  671.     FormDQViewText.ShowModal;
  672.     FormDQViewText.Free;
  673. End;
  674. Procedure TFormQuery.BBBDEClick(Sender: TObject);
  675. Begin
  676.     FormDQAddTable    := TFormDQAddTable.Create (Self);
  677.   FormDQAddTable.bMultiDB    := bMultiDB;
  678.     FormDQAddTable.EveneAdd    := AddTable;
  679.   FormDQAddTable.ShowModal;
  680.   bMultiDB        := FormDQAddTable.bMultiDB;
  681.     FormDQAddTable.Free;
  682. End;
  683. Procedure TFormQuery.BBTableClick(Sender: TObject);
  684. Var
  685.     St:        String;
  686.   iTemp:    Integer;
  687. Begin
  688.     if OpenDBDlg.Execute Then
  689.   Begin
  690.         St    := OpenDBDlg.FileName;
  691.         StDataBase    := ExtractFilePath (St);
  692.         StTable        := ExtractFileName (St);
  693.      StAlias        := StTable;
  694.      St                := ExtractFileExt (StTable);
  695.      iTemp            := Length (St);
  696.         Delete (StAlias, Length (StTable) - iTemp + 1, iTemp);
  697.      NewTable;
  698.   End;
  699. End;
  700. Procedure TFormQuery.BBRemoveTableClick(Sender: TObject);
  701. Var
  702.     StAlias:        String;
  703.   ItemIndex:    Integer;
  704. Begin
  705.     ItemIndex    := LBTable.ItemIndex;
  706.     if ItemIndex < 0 Then Exit;
  707.   StAlias        := LBTable.Items.Strings[ItemIndex];
  708.   LBTable.Items.Delete (ItemIndex);
  709.     RemoveFieldInfoToAllControl (StAlias);
  710. End;
  711.  
  712. { Link }
  713. Procedure TFormQuery.BBDeleteLinkClick(Sender: TObject);
  714. Begin
  715.     LinkCtrl.DeleteLineActive;
  716. End;
  717. Procedure TFormQuery.BBOptionLineClick(Sender: TObject);
  718. Begin
  719.     LinkCtrl.OptionLineActive;
  720. End;
  721. Procedure TFormQuery.BBArrangeClick(Sender: TObject);
  722. Begin
  723.     LinkCtrl.Arrange;
  724. End;
  725. Procedure TFormQuery.LinkCtrlNewLink(Sender: TObject);
  726. Begin
  727. //    asd
  728. End;
  729. Procedure TFormQuery.LinkCtrlSelectLinkEvent(Sender: TObject;
  730.   bSelect: Boolean);
  731. Begin
  732.     BBDeleteLink.Enabled    := bSelect;
  733. End;
  734. Procedure TFormQuery.GetTableLink;
  735. Var
  736.     QueryLink:        RQueryLink;
  737.   i:                    Integer;
  738.   Link:                RDQLink;
  739. Begin
  740.     DuckQuery.DQTableLinks.Clear;
  741.   For i := 0 To LinkCtrl.TableLink.Count - 1 Do
  742.   Begin
  743.         if not LinkCtrl.GetLink (i, QueryLink) Then Continue;
  744.      Link.MAlias    := QueryLink.MAlias;
  745.      Link.MField    := QueryLink.MField;
  746.      Link.TableLinkType    := TDQLinkType (QueryLink.QueryLinkType);
  747.      Link.DAlias    := QueryLink.DAlias;
  748.      Link.DField    := QueryLink.DField;
  749.  
  750.      DuckQuery.DQTableLinks.Add (@Link);
  751.   End;
  752. End;
  753. { Select Fields }
  754. Procedure TFormQuery.SelectField;
  755. Var
  756.     StAlias:        String;
  757.   StField:        String;
  758.   StFunction:    String;
  759.   StData:        String;
  760.     StColumnName:    String;
  761.   Procedure    AutoSelectField (StAlias, StField, StFunction: String;
  762.                       Var StData, StColumnName: String);
  763.     Var
  764.         StF:        String;
  765.     Begin
  766.         StF    := StAlias + '.' + '''' + StField + '''';
  767.       StFunction        := UpperCase (StFunction);
  768.       if StFunction = 'SUM' Then        StData    := 'SUM (' + StF + ')'
  769.       Else
  770.       if StFunction = 'AVG' Then        StData    := 'AVG (' + StF + ')'
  771.       Else
  772.       if StFunction = 'COUNT' Then    StData    := 'COUNT (' + StF + ')'
  773.       Else
  774.       if StFunction = 'MIN' Then        StData    := 'MIN (' + StF + ')'
  775.       Else
  776.       if StFunction = 'MAX' Then        StData    := 'MAX (' + StF + ')'
  777.       Else
  778.       if StFunction = 'UPPER' Then    StData    := 'UPPER (' + StF + ')'
  779.       Else
  780.       if StFunction = 'LOWER' Then    StData    := 'LOWER (' + StF + ')'
  781.       Else
  782.       if StFunction = 'TRIM' Then    StData    := 'TRIM (' + StF + ')'
  783.       Else
  784.       if StFunction = 'SUBSTRING' Then StData    := 'SUBSTRING (' + StF + ', 1, 20)'
  785.       Else    StData    := StF;
  786.       if StFunction = '' Then    StColumnName    := StField
  787.       Else    StColumnName    := StFunction + StField;
  788.         StColumnName    := CheckColumnName (StColumnName);
  789.         CheckColumnNameDup (StColumnName);
  790.     End;
  791.  
  792. Begin
  793.     StField            := FieldSelect (FieldAllField, StAlias);
  794.     if (StAlias = '') or (StField = '') Then Exit;
  795.   StFunction        := CBFunction.Text;
  796.     AutoSelectField (StAlias, StField, StFunction, StData, StColumnName);
  797.  
  798.     ESelectField.Text    := StData;
  799.     EColumnName.Text    := StColumnName;
  800. End;
  801. Procedure TFormQuery.EnabledField;
  802. Begin
  803.   BBFieldsRemove.Enabled    := ListBoxSelect.Items.Count > 0;
  804.   BBRemoveShowAll.Enabled    := BBFieldsRemove.Enabled;
  805. End;
  806. Procedure TFormQuery.AddFieldWithAlias (StAlias: String);
  807. Var
  808.   Items:            TStrings;
  809.   i:                    Integer;
  810.   TableInfoPtr:    PRDQTableInfo;
  811.   StData:            String;
  812.     StColumnName:    String;
  813.   DQField:            RDQField;
  814. Begin
  815.   TableInfoPtr    := DuckQuery.TableInfo.FindAsStringPt (StAlias);
  816.   if TableInfoPtr = nil Then Exit;
  817.  
  818.   Items        := TStringList.Create;
  819.   Try
  820.      Items.Assign (TableInfoPtr.FieldName);
  821.      For i := 0 To Items.Count - 1 Do
  822.      Begin
  823.         StData            := StAlias + '.''' + Items[i] + '''';
  824.             StColumnName    := Items[i];
  825.         StColumnName    := CheckColumnName (StColumnName);
  826.             if DuckQuery.DQFields.FindAsStringPt (StColumnName) <> nil Then Continue;
  827.             ListBoxSelect.Items.Add (StColumnName);
  828.           DQField.Data        := StData;
  829.           DQField.ColumnName:= StColumnName;
  830.             DuckQuery.DQFields.Add (@DQField);
  831.      End;
  832.   Finally
  833.       Items.Free;
  834.     End;
  835.   EnabledField;
  836. End;
  837. Procedure TFormQuery.BBFieldsAddClick(Sender: TObject);
  838. Var
  839.   StField, StAlias:    String;
  840.   StData:                String;
  841.     StColumnName:        String;
  842.   DQField:                RDQField;
  843. Begin
  844.     if not BBFieldsAdd.Enabled Then Exit;
  845.     StField            := FieldSelect (FieldAllField, StAlias);
  846.     if (StAlias = '') or (StField = '') Then Exit;
  847.   StData            := ESelectField.Text;
  848.     StColumnName    := EColumnName.Text;
  849.  
  850.     CheckColumnNameDup (StColumnName);
  851.  
  852.     ListBoxSelect.Items.Add (StColumnName);
  853.   DQField.Data        := StData;
  854.   DQField.ColumnName:= StColumnName;
  855.   DuckQuery.DQFields.Add (@DQField);
  856.   EnabledField;
  857. End;
  858. Procedure TFormQuery.BBFieldsRemoveClick(Sender: TObject);
  859. Var
  860.     iCount:            Integer;
  861.   StColumnName:    String;
  862. Begin
  863.     if not BBFieldsRemove.Enabled Then Exit;
  864.   if ListBoxSelect.Items.Count <= 0 Then Exit;
  865.     iCount    := ListBoxSelect.ItemIndex;
  866.   if (iCount < 0) OR (iCount >= ListBoxSelect.Items.Count) Then Exit;
  867.   DuckQuery.DQFields.Delete (iCount);
  868.   ListBoxSelect.Items.Delete (iCount);
  869.  
  870.   if ListBoxSelect.Items.Count > 0 Then
  871.       if iCount >= ListBoxSelect.Items.Count Then
  872.             ListBoxSelect.ItemIndex    := ListBoxSelect.Items.Count - 1
  873.      else
  874.         ListBoxSelect.ItemIndex    := iCount;
  875.   EnabledField;
  876. End;
  877. Procedure TFormQuery.BBAddShowTableClick(Sender: TObject);
  878. Var
  879.     StAlias:            String;
  880. Begin
  881.     StAlias    := GetAlias (FieldAllField);
  882.     if StAlias = '' Then Exit;
  883.     AddFieldWithAlias (StAlias);
  884.     EnabledField;
  885. End;
  886. Procedure TFormQuery.BBAddFieldsClick(Sender: TObject);
  887. Var
  888.     i:                    Integer;
  889.   StAlias:            String;
  890.   TableInfoPtr:    PRDQTableInfo;
  891. Begin
  892.     For i := 0 To DuckQuery.TableInfo.Count - 1 Do
  893.   Begin
  894.       TableInfoPtr    := DuckQuery.TableInfo[i];
  895.         StAlias            := TableInfoPtr.Alias;
  896.      AddFieldWithAlias (StAlias);
  897.   End;
  898.     EnabledField;
  899. End;
  900. Procedure TFormQuery.BBRemoveShowAllClick(Sender: TObject);
  901. Begin
  902.     DuckQuery.DQFields.Clear;
  903.   ListBoxSelect.Clear;
  904.     EnabledField;
  905. End;
  906. Procedure TFormQuery.FieldAllFieldClick(Sender: TObject);
  907. Begin
  908.     SelectField;
  909. End;
  910. Procedure TFormQuery.CBFunctionClick(Sender: TObject);
  911. Begin
  912.     SelectField;
  913. End;
  914. Procedure TFormQuery.ListBoxSelectDragDrop(Sender, Source: TObject; X,
  915.   Y: Integer);
  916. Var
  917.     iSelect:    Integer;
  918.   iIndex:    Integer;
  919. Begin
  920.   iSelect    := ListBoxSelect.ItemAtPos (Point (x, y), TRUE);
  921.   iIndex    := ListBoxSelect.ItemIndex;
  922.   if (iSelect < 0) or (iSelect >= ListBoxSelect.Items.Count) Then Exit;
  923.   if (iIndex < 0) or (iIndex >= ListBoxSelect.Items.Count) Then Exit;
  924.  
  925.     ListBoxSelect.Items.Move (iIndex, iSelect);
  926.     DuckQuery.DQFields.Move (iIndex, iSelect);
  927. End;
  928. Procedure TFormQuery.ListBoxSelectDragOver(Sender, Source: TObject; X,
  929.   Y: Integer; State: TDragState; var Accept: Boolean);
  930. Begin
  931.     Accept    := (Sender = Source);
  932. End;
  933.  
  934. { ------------ Sort}
  935. Procedure TFormQuery.BBSortAddClick(Sender: TObject);
  936. Var
  937.     i:            Integer;
  938.   St:        String;
  939.   DQSort:    RDQSort;
  940. Begin
  941.     i    := LBSortAll.ItemIndex;
  942.     if (i < 0) or (i >= LBSortAll.Items.Count) Then Exit;
  943.   St    := LBSortAll.Items[i];
  944.   if St = '' Then Exit;
  945.     DQSort.Field        := St;
  946.   DQSort.SortType    := gsAscending;
  947.   DuckQuery.DQSorts.Add (@DQSort);
  948.  
  949.   Case DQSort.SortType of
  950.         gsAscending:    St    := 'A - ';
  951.       gsDecending:    St    := 'D - ';
  952.   End;
  953.   St    := St + DQSort.Field;
  954.     LBSort.Items.Add (St);
  955.     BBSortRemove.Enabled    := LBSort.Items.Count > 0;
  956. //    ASD
  957. End;
  958. Procedure TFormQuery.BBSortRemoveClick(Sender: TObject);
  959. Var
  960.     i:            Integer;
  961. Begin
  962.     i    := LBSort.ItemIndex;
  963.     if (i < 0) or (i >= LBSort.Items.Count) Then Exit;
  964.   LBSort.Items.Delete (i);
  965.     DuckQuery.DQSorts.Delete (i);
  966.     BBSortRemove.Enabled    := LBSort.Items.Count > 0;
  967. End;
  968. Procedure TFormQuery.RGSortClick(Sender: TObject);
  969. Var
  970.     i:            Integer;
  971.   iT:        Integer;
  972.   St:        String;
  973.   SortPtr:    PRDQSort;
  974. Begin
  975.     i    := LBSort.ItemIndex;
  976.     if (i < 0) or (i >= LBSort.Items.Count) Then Exit;
  977.   SortPtr    := DuckQuery.DQSorts[i];
  978.     iT            := RGSort.ItemIndex;
  979.   Case iT of
  980.         0:
  981.          Begin
  982.             SortPtr.SortType    := gsAscending;
  983.            St    := 'A - ';
  984.         End;
  985.       1:
  986.          Begin
  987.             SortPtr.SortType    := gsDecending;
  988.            St    := 'D - ';
  989.         End;
  990.   End;
  991.   St    := St + SortPtr.Field;
  992.     LBSort.Items[i]    := St;
  993. End;
  994. Procedure TFormQuery.LBSortClick(Sender: TObject);
  995. Var
  996.     i:            Integer;
  997.   St:        String;
  998. Begin
  999.     i    := LBSort.ItemIndex;
  1000.     if (i < 0) or (i >= LBSort.Items.Count) Then Exit;
  1001.     St    := LBSort.Items[i];
  1002.   Case St[1] of
  1003.         'A': RGSort.ItemIndex    := 0;
  1004.       'D': RGSort.ItemIndex    := 1;
  1005.   End;
  1006. End;
  1007. Procedure TFormQuery.LBSortDragDrop(Sender, Source: TObject; X,
  1008.   Y: Integer);
  1009. Var
  1010.     iSelect:    Integer;
  1011.   iIndex:    Integer;
  1012. Begin
  1013.   iSelect    := LBSort.ItemAtPos (Point (x, y), TRUE);
  1014.   iIndex    := LBSort.ItemIndex;
  1015.   if (iSelect < 0) or (iSelect >= LBSort.Items.Count) Then Exit;
  1016.   if (iIndex < 0) or (iIndex >= LBSort.Items.Count) Then Exit;
  1017.     LBSort.Items.Move (iIndex, iSelect);
  1018.     DuckQuery.DQSorts.Move (iIndex, iSelect);
  1019. End;
  1020. Procedure TFormQuery.LBSortDragOver(Sender, Source: TObject; X, Y: Integer;
  1021.   State: TDragState; var Accept: Boolean);
  1022. Begin
  1023.     Accept    := (Sender = Source);
  1024. End;
  1025.  
  1026. { DQGroups }
  1027. Procedure TFormQuery.BBGroupAddClick(Sender: TObject);
  1028. Var
  1029.     i:                Integer;
  1030.   St:            String;
  1031.   DQGroup:        RDQGroup;
  1032. Begin
  1033.     i    := LBGroupsAll.ItemIndex;
  1034.     if (i < 0) or (i >= LBGroupsAll.Items.Count) Then Exit;
  1035.   St    := LBGroupsAll.Items[i];
  1036.   if St = '' Then Exit;
  1037.  
  1038.     DQGroup.Field        := St;
  1039.   DuckQuery.DQGroups.Add (@DQGroup);
  1040.   LBGroup.Items.Add (St);
  1041.     BBGroupRemove.Enabled    := LBGroup.Items.Count > 0;
  1042. //    ASD
  1043. End;
  1044. Procedure TFormQuery.BBGroupRemoveClick(Sender: TObject);
  1045. Var
  1046.     i:            Integer;
  1047. Begin
  1048.     i    := LBGroup.ItemIndex;
  1049.     if (i < 0) or (i >= LBGroup.Items.Count) Then Exit;
  1050.   LBGroup.Items.Delete (i);
  1051.     DuckQuery.DQGroups.Delete (i);
  1052.     BBGroupRemove.Enabled    := LBGroup.Items.Count > 0;
  1053. End;
  1054. procedure TFormQuery.LBGroupDragDrop(Sender, Source: TObject; X,
  1055.   Y: Integer);
  1056. Var
  1057.     iSelect:    Integer;
  1058.   iIndex:    Integer;
  1059. Begin
  1060.   iSelect    := LBGroup.ItemAtPos (Point (x, y), TRUE);
  1061.   iIndex    := LBGroup.ItemIndex;
  1062.   if (iSelect < 0) or (iSelect >= LBGroup.Items.Count) Then Exit;
  1063.   if (iIndex < 0) or (iIndex >= LBGroup.Items.Count) Then Exit;
  1064.     LBGroup.Items.Move (iIndex, iSelect);
  1065.     DuckQuery.DQGroups.Move (iIndex, iSelect);
  1066. End;
  1067. Procedure TFormQuery.LBGroupDragOver(Sender, Source: TObject; X,
  1068.   Y: Integer; State: TDragState; var Accept: Boolean);
  1069. Begin
  1070.     Accept    := (Sender = Source);
  1071. End;
  1072. { Criteria }
  1073. Procedure TFormQuery.VisibleCriteria (bV1, bV2: Boolean);
  1074. Begin
  1075.   CBValue1.Visible    := bV1;
  1076.   SBValue1.Visible    := bV1;
  1077.  
  1078.   LabelAnd.Visible    := bV2;
  1079.   CBValue2.Visible    := bV2;
  1080.   SBValue2.Visible    := bV2;
  1081. End;
  1082. Procedure TFormQuery.CBFieldClick(Sender: TObject);
  1083. Var
  1084.     i:        Integer;
  1085. Begin
  1086.     i    := CBField.ItemIndex;
  1087.   if i >= 0 Then
  1088.   Begin
  1089.       if not CBCommand.Visible Then
  1090.          CBCommand.ItemIndex    := -1;
  1091.       CBCommand.Visible    := TRUE;
  1092.      VisibleCriteria (FALSE, FALSE);
  1093.   End;
  1094. End;
  1095. Procedure TFormQuery.CBCommandClick(Sender: TObject);
  1096. Var
  1097.     i:                    Integer;
  1098.   CriteriaType:    TDQCriteriaType;
  1099. Begin
  1100.     i    := CBCommand.ItemIndex;
  1101.     CriteriaType    := TDQCriteriaType (i + 1);
  1102.   Case CriteriaType of
  1103.         scEqual,
  1104.      scNotEqual,
  1105.      scLess,
  1106.      scLessEqual,
  1107.         scGreater,
  1108.      scGreaterEqual,
  1109.      scLike,
  1110.      scNotLike,
  1111.      scIN:
  1112.          VisibleCriteria (TRUE, FALSE);
  1113.      scNOTNULL,
  1114.      scNULL:
  1115.          VisibleCriteria (FALSE, FALSE);
  1116.      scBetween,
  1117.      scBetweenEqual:
  1118.          VisibleCriteria (TRUE, TRUE);
  1119.   End;
  1120. End;
  1121. Procedure TFormQuery.GetCriterias (Var DQCriterias: RDQCriterias);
  1122. Var
  1123.   CriteriaType:    TDQCriteriaType;
  1124.   i:                    Integer;
  1125. Begin
  1126.     DQCriterias.Field    := CBField.Text;
  1127.   i                    := CBCommand.ItemIndex;
  1128.     CriteriaType    := TDQCriteriaType (i + 1);
  1129.   DQCriterias.CriteriaType    := CriteriaType;
  1130.   DQCriterias.Value1        := CBValue1.Text;
  1131.   DQCriterias.Value2        := CBValue2.Text;
  1132.   DQCriterias.AddType        := TDQCriteriaAdd (RBCriteriaWith.ItemIndex);
  1133. End;
  1134. Procedure TFormQuery.SetCriterias (DQCriterias: RDQCriterias);
  1135. Begin
  1136.   CBValue2.Text            := DQCriterias.Value2;
  1137.   CBValue1.Text            := DQCriterias.Value1;
  1138.   CBField.ItemIndex        := CBField.Items.IndexOf (DQCriterias.Field);
  1139.   CBCommand.Visible        := TRUE;
  1140.     CBCommand.ItemIndex    := Integer (DQCriterias.CriteriaType) - 1;
  1141.   RBCriteriaWith.ItemIndex        := Integer (DQCriterias.AddType);
  1142.   CBCommandClick (nil);
  1143. End;
  1144. Procedure TFormQuery.BBAddClick(Sender: TObject);
  1145. Var
  1146.     DQCriterias:    RDQCriterias;
  1147.   St:                String;
  1148. Begin
  1149.     GetCriterias (DQCriterias);
  1150.     DuckQuery.DQCriterias.Add (@DQCriterias);
  1151.     St    := CriteriasAsString (DuckQuery.DQCriterias.Count - 1, @DQCriterias);
  1152.   LBSelect.Items.Add (St);
  1153.   BBRemove.Enabled    := LBSelect.Items.Count > 0;
  1154.   BBClearClick(nil);
  1155. End;
  1156. Procedure TFormQuery.BBRemoveClick(Sender: TObject);
  1157. Var
  1158.     i:            Integer;
  1159. Begin
  1160.     i    := LBSelect.ItemIndex;
  1161.     if (i < 0) or (i >= LBSelect.Items.Count) Then Exit;
  1162.     LBSelect.Items.Delete (i);
  1163.     DuckQuery.DQCriterias.Delete (i);
  1164.     BBRemove.Enabled    := LBSelect.Items.Count > 0;
  1165.   BBClearClick (nil);
  1166. End;
  1167. Procedure TFormQuery.BBEditClick(Sender: TObject);
  1168. Var
  1169.     CriteriasPtr:    PRDQCriterias;
  1170.   i:                    Integer;
  1171.   St:                String;
  1172. Begin
  1173.     i            := LBSelect.ItemIndex;
  1174.   if (i < 0) or (i >= LBSelect.Items.Count) Then Exit;
  1175.     CriteriasPtr    := DuckQuery.DQCriterias[i];
  1176.   GetCriterias (CriteriasPtr^);
  1177.   St    := CriteriasAsString (i, CriteriasPtr);
  1178.   LBSelect.Items[i]    := St;
  1179. End;
  1180. Procedure TFormQuery.BBClearClick(Sender: TObject);
  1181. Begin
  1182.     VisibleCriteria (FALSE, FALSE);
  1183.   CBField.ItemIndex    := -1;
  1184.   CBCommand.Visible    := FALSE;
  1185.   CBValue1.Text        := '';
  1186.   CBValue2.Text        := '';
  1187.  
  1188.     RBCriteriaWith.Visible    := DuckQuery.DQCriterias.Count > 0;
  1189.   
  1190.   CBField.SetFocus;
  1191. End;
  1192. Procedure TFormQuery.LBSelectClick(Sender: TObject);
  1193. Var
  1194.     CriteriasPtr:    PRDQCriterias;
  1195.   i:                Integer;
  1196. Begin
  1197.     i            := LBSelect.ItemIndex;
  1198.   if (i < 0) or (i >= LBSelect.Items.Count) Then Exit;
  1199.   CriteriasPtr    := DuckQuery.DQCriterias[i];
  1200.   SetCriterias (CriteriasPtr^);
  1201. End;
  1202. Procedure TFormQuery.LBSelectDragOver(Sender, Source: TObject; X,
  1203.   Y: Integer; State: TDragState; var Accept: Boolean);
  1204. Begin
  1205.     Accept    := (Sender = Source);
  1206. End;
  1207. Procedure TFormQuery.LBSelectDragDrop(Sender, Source: TObject; X,
  1208.   Y: Integer);
  1209. Var
  1210.     iSelect:    Integer;
  1211.   iIndex:    Integer;
  1212. Begin
  1213.   iSelect    := LBSelect.ItemAtPos (Point (x, y), TRUE);
  1214.   iIndex    := LBSelect.ItemIndex;
  1215.   if (iSelect < 0) or (iSelect >= LBSelect.Items.Count) Then Exit;
  1216.   if (iIndex < 0) or (iIndex >= LBSelect.Items.Count) Then Exit;
  1217.     LBSelect.Items.Move (iIndex, iSelect);
  1218.     DuckQuery.DQCriterias.Move (iIndex, iSelect);
  1219. End;
  1220. Procedure TFormQuery.GetTableAndField (StColumn: String; Var StDB, StTable, StAlias, StField: String);
  1221. Var
  1222.     FieldPtr:    PRDQField;
  1223.   TablePtr:    PRDQTable;
  1224.   iPos:            Integer;
  1225. Begin
  1226.     StDB        := '';
  1227.     StAlias    := '';
  1228.     StField    := '';
  1229.     FieldPtr    := DuckQuery.DQFields.FindAsStringPt (StColumn);
  1230.     if FieldPtr = nil Then Exit;
  1231.     iPos        := Pos ('.', FieldPtr.Data);
  1232.     if iPos > 0 Then
  1233.         StTable    := Copy (FieldPtr.Data, 1, iPos - 1);
  1234.  
  1235.   iPos        := Pos ('.', FieldPtr.Data);
  1236.     if iPos > 0 Then
  1237.         StField    := Copy (FieldPtr.Data, iPos + 1, Length (FieldPtr.Data) - iPos);
  1238.  
  1239.   TablePtr    := DuckQuery.DQTables.FindAsStringPt (StTable);
  1240.   if TablePtr = nil Then Exit;
  1241.   StTable    := TablePtr.Table;
  1242.   StDB        := TablePtr.DataBase;
  1243.   StAlias    := TablePtr.Alias;
  1244. End;
  1245. Procedure TFormQuery.SBValue1Click(Sender: TObject);
  1246. Var
  1247.     i:                    Integer;
  1248.   CriteriaType:    TDQCriteriaType;
  1249.   StColumn:        String;
  1250.     StDB, StTable, StField, StAlias: String;
  1251. Begin
  1252.   i                    := CBCommand.ItemIndex;
  1253.     CriteriaType    := TDQCriteriaType (i + 1);
  1254.     StColumn            := CBField.Text;
  1255.   GetTableAndField (StColumn, StDB, StTable, StAlias, StField);
  1256.     FormDQSelectValue    := TFormDQSelectValue.Create (Self);
  1257.     FormDQSelectValue.bString    := TRUE;
  1258.     FormDQSelectValue.GetFieldValueString (StDB, StTable,
  1259.       StAlias, StColumn, DuckQuery.DBSession);
  1260.   Case CriteriaType of
  1261.       scIN:
  1262.          Begin
  1263.             FormDQSelectValue.LBValue.MultiSelect        := TRUE;
  1264.            FormDQSelectValue.LBValue.ExtendedSelect    := FALSE;
  1265.         End;
  1266.   End;
  1267.   FormDQSelectValue.ShowModal;
  1268.     if FormDQSelectValue.ModalResult = mrOK Then
  1269.         CBValue1.Text    := FormDQSelectValue.StValue;
  1270.     CBValue1.SetFocus;
  1271.     FormDQSelectValue.Free;
  1272. End;
  1273. Procedure TFormQuery.SBValue2Click(Sender: TObject);
  1274. Var
  1275.     i:                    Integer;
  1276.   StColumn:        String;
  1277.   StDB, StTable, StField, StAlias: String;
  1278. Begin
  1279.   i                := CBCommand.ItemIndex;
  1280.   StColumn        := CBField.Text;
  1281.   GetTableAndField (StColumn, StDB, StTable, StAlias, StField);
  1282.   FormDQSelectValue    := TFormDQSelectValue.Create (Self);
  1283.  
  1284.     FormDQSelectValue.bString    := TRUE;
  1285.     FormDQSelectValue.GetFieldValueString (StDB, StTable,
  1286.       StAlias, StColumn, DuckQuery.DBSession);
  1287.   FormDQSelectValue.ShowModal;
  1288.     if FormDQSelectValue.ModalResult = mrOK Then
  1289.         CBValue2.Text    := FormDQSelectValue.StValue;
  1290.     CBValue2.SetFocus;
  1291.     FormDQSelectValue.Free;
  1292. End;
  1293. Procedure TFormQuery.NewTable;
  1294. Var
  1295.     DRTable:    RDQTable;
  1296. Begin
  1297.     if DuckQuery.DQTables.FindAsStringPt (StAlias) <> nil Then
  1298.     Begin
  1299.         MessageBoxFormatWarning (IDW_ALIAS_REDEFINE, [StAlias]);
  1300.         Exit;
  1301.     End;
  1302.     LBTable.Items.Add (StAlias);
  1303.   DRTable.DataBase    := StDataBase;
  1304.     DRTable.Table        := StTable;
  1305.     DRTable.Alias        := StAlias;
  1306.   DuckQuery.DQTables.Add (@DRTable);
  1307.     CreateTableInfo (StDataBase, StTable, StAlias, TRUE);
  1308.     AddFieldInfoToAllControl (StAlias);
  1309. End;
  1310.  
  1311. Procedure TFormQuery.TNotebookChange(Sender: TObject; NewTab: Integer;
  1312.   var AllowChange: Boolean);
  1313. Begin
  1314.     Caption    := TNotebook.Pages[NewTab];
  1315.     if TNotebook.PageIndex = 2 Then
  1316.         LoadFieldToScreen;
  1317. End;
  1318.  
  1319. Procedure TFormQuery.LoadFieldToScreen;
  1320. Var
  1321.   Items:    TStrings;
  1322. Begin
  1323.     Items        := TStringList.Create;
  1324.     GetSelectField (Items);
  1325.     Try
  1326.         CBField.Items.Assign (Items);
  1327.         LBGroupsAll.Items.Assign (Items);
  1328.         LBSortAll.Items.Assign (Items);
  1329.   Finally
  1330.       Items.Free;
  1331.   End;
  1332. End;
  1333.  
  1334. End.
  1335. {
  1336. Procedure TFormQuery.TNotebookChange(Sender: TObject; NewTab: Integer;
  1337.   var AllowChange: Boolean);
  1338. Var
  1339.   Items:    TStrings;
  1340. Begin
  1341.   Caption    := TNotebook.Pages[NewTab];
  1342.   if NewTab in [3, 4, 5] Then
  1343.   Begin
  1344.       Items        := TStringList.Create;
  1345.      GetSelectField (Items);
  1346.       Try
  1347.           Case NewTab of
  1348.              3:    CBField.Items.Assign (Items);
  1349.               4: LBGroupsAll.Items.Assign (Items);
  1350.              5: LBSortAll.Items.Assign (Items);
  1351.           End;
  1352.       Finally
  1353.           Items.Free;
  1354.       End;
  1355.   End;
  1356. End;
  1357. }
  1358.